package org.ee.core.util;

import com.google.common.base.Strings;
import com.google.common.cache.Cache;
import com.google.common.cache.CacheBuilder;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.google.common.collect.Sets;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.ListeningExecutorService;
import com.google.common.util.concurrent.MoreExecutors;

import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.Callable;
import java.util.concurrent.TimeUnit;

/**
 * Guava工具类
 * @Author jokr
 * @Date 2025/8/26 下午2:58
 */
public class GuavaUtil {

    /**
     * 判断字符串是否为空（null 或空字符串）
     *
     * @param str 字符串
     * @return 如果字符串为空，返回 true；否则返回 false
     */
    public static boolean isNullOrEmpty(String str) {
        return Strings.isNullOrEmpty(str);
    }

    /**
     * 如果字符串为 null，则返回默认值，否则返回原字符串
     *
     * @param str          字符串
     * @param defaultValue 默认值
     * @return 返回非 null 字符串
     */
    public static String nullToEmpty(String str, String defaultValue) {
        return Strings.nullToEmpty(str).isEmpty() ? defaultValue : str;
    }

    /**
     * 创建一个空的 List（不可变）
     *
     * @param <T> 元素类型
     * @return 空的不可变 List
     */
    public static <T> List<T> createEmptyList() {
        return Lists.newArrayList();
    }

    /**
     * 创建一个不可变的 Set
     *
     * @param values 需要放入 Set 中的元素
     * @param <T>    元素类型
     * @return 不可变的 Set
     */
    public static <T> Set<T> createImmutableSet(T... values) {
        return Sets.newHashSet(values);
    }

    /**
     * 使用 Guava 缓存，设置最大容量和过期时间
     *
     * @return 缓存对象
     */
    public static Cache<String, String> createCache() {
        return CacheBuilder.newBuilder()
                .maximumSize(100)  // 设置最大缓存数量
                .expireAfterWrite(10, TimeUnit.SECONDS)  // 设置过期时间
                .build();
    }

    /**
     * 使用 Guava 缓存，设置最大容量和过期时间
     * @param maximumSize
     * @param duration
     * @return
     */
    public static Cache<String,String> createCache(Long maximumSize, long duration){
        return CacheBuilder.newBuilder()
                .maximumSize(maximumSize)  // 设置最大缓存数量
                .expireAfterWrite(duration, TimeUnit.SECONDS)  // 设置过期时间
                .build();
    }

    /**
     * 提交一个 Callable 任务并返回 ListenableFuture
     *
     * @param executorService 执行任务的服务
     * @param task            执行的任务
     * @return 返回 ListenableFuture
     */
    public static ListenableFuture<String> submitTask(ListeningExecutorService executorService, Callable<String> task) {
        return executorService.submit(task);
    }

    /**
     * 创建一个 ListeningExecutorService
     *
     * @return ListeningExecutorService
     */
    public static ListeningExecutorService createExecutorService() {
        return MoreExecutors.listeningDecorator(java.util.concurrent.Executors.newFixedThreadPool(5));
    }

    /**
     * 连接集合中的字符串
     *
     * @param delimiter 分隔符
     * @param elements  元素列表
     * @return 连接后的字符串
     */
    public static String joinStrings(String delimiter, List<String> elements) {
        return String.join(delimiter, elements);
    }

    /**
     * 分割字符串为集合
     *
     * @param str       需要分割的字符串
     * @param delimiter 分隔符
     * @return 返回一个 List
     */
    public static List<String> splitString(String str, String delimiter) {
        return Lists.newArrayList(str.split(delimiter));
    }

    /**
     * 快速创建不可变Map
     * @param entries key-value对
     * @return ImmutableMap
     */
    @SafeVarargs
    public static <K, V> ImmutableMap<K, V> of(Object... entries) {
        if (entries.length % 2 != 0) {
            throw new IllegalArgumentException("Entries should be key-value pairs");
        }
        ImmutableMap.Builder<K, V> builder = ImmutableMap.builder();
        for (int i = 0; i < entries.length; i += 2) {
            @SuppressWarnings("unchecked")
            K key = (K) entries[i];
            @SuppressWarnings("unchecked")
            V value = (V) entries[i + 1];
            builder.put(key, value);
        }
        return builder.build();
    }

    /**
     * 创建可变Map
     * @param entries key-value对
     * @return HashMap
     */
    @SafeVarargs
    public static <K, V> Map<K, V> newHashMap(Object... entries) {
        Map<K, V> map = Maps.newHashMap();
        if (entries.length % 2 != 0) {
            throw new IllegalArgumentException("Entries should be key-value pairs");
        }
        for (int i = 0; i < entries.length; i += 2) {
            @SuppressWarnings("unchecked")
            K key = (K) entries[i];
            @SuppressWarnings("unchecked")
            V value = (V) entries[i + 1];
            map.put(key, value);
        }
        return map;
    }
}